Programmieren

Ingenieurinformatik Teil 1, Wintersemester 2025/26

David Straub

Gliederung

1. Einführung
2. Grundlagen: Variablen, Datentypen, Verzweigungen
3. Funktionen
4. Schleifen
5. Datenstrukturen
6. Module & Bibliotheken
7. Klassen
8. Dateien
9. Visualisierung
10. Numerik

Einführung

1. Warum Programmieren?
2. Organisatorisches
3. Warum Python?
4. Python installieren

Warum Python? Einfachheit

Python:

print("Hallo Welt!")

Java:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hallo Welt!");
    }
}

Einfachheit: Liste der Quadrate der Zahlen von 0 bis 9

Python:

quadrate = [x**2 for x in range(10)]

Fortran:

program quadrate
implicit none
integer :: i
integer, dimension(10) :: quadrate
do i = 0, 9
    quadrate(i+1) = i**2
end do
end program quadrate

Beliebtheit

Quelle: TIOBE

Warum Beliebtheit wichtig ist

• Mehr Bibliotheken
• Mehr Dokumentation
• Mehr Jobs
• Bessere KI-Unterstützung

Mythen über Python

Früher verbreitete Mythen über Python:

• Nur für Skripting
• Nur für Anfänger
• Langsam

Heute:

• Industriestandard für ML/AI
• Standard für wissenschaftliches Rechnen
• Weit verbreitet in Webentwicklung, Automatisierung, uvm.

Zusammenfassung: Warum Python?

• Sehr einfach
• Extrem beliebt
• Weit verbreitet in Industrie und Wissenschaft
• Quelloffen & kostenlos

Python installieren

• Anders als z.B. C++ ist Python eine interpretierte Programmiersprache, d.h. der Code wird zur Laufzeit Zeile für Zeile ausgeführt.
• Das ausführende Programm heißt Interpreter und ist für alle gängigen Betriebssysteme verfügbar.

Anleitung:

• Windows: https://www.python.org/downloads/windows/ – herunterladen & installieren
  • oder einfach WSL
• Ubuntu: sudo apt install python3 python3-pip
• MacOS: brew install python

Bitte kein Anaconda …

Versionsgeschichte

• Details: Status of Python Versions
• Diese Veranstaltung: Python 3.10 oder höher (3.12 oder 3.13 empfohlen)

Konsole, Skript, Notebook

• Konsole: interaktive Eingabe von Python-Befehlen
  • nützlich als schneller Taschenrechner
• Skript: Python-Code in einer Datei mit der Endung .py
  • nützlich für längere Programme
• Jupyter Notebook: interaktive Umgebung für Datenanalyse und Visualisierung
  • nützlich für explorative Programmierung

Python ausprobieren, ohne es zu installieren

• Python Online: https://pythononline.net/
• JupyterLite: https://jupyter.org/try
• FK07 DataHub (JupyterHub): https://datahub.cs.hm.edu/
• Github Codespaces: https://github.com/DavidMStraub/python-codespace

One-Minute-Paper

Moodle: https://link.hm.edu/y4vj

• Schreiben Sie 3 Dinge auf, die Sie heute gelernt haben
• Was war am unklarsten?
• Gibt es etwas spezielles, das Sie in diesem Kurs lernen möchten?

Grundlagen

1. Variablen
2. Einfache Datentypen (int, bool, float, str)
3. Verzweigungen

Variablen

Variablen speichern Werte:

x = 42
y = x
x = 100
print(y)

print(x)

Variablennamen: Fallstricke

# class = "Mathematik"  # SyntaxError!
klass = "Mathematik"
print(klass)

# Schlecht lesbar:
l = 1
I = 1  
O = 0
print(l, I, O)

Namen: Konventionen

# Variablen & Funktionen: snake_case 
first_name = "Alice"
calculate_average()

# Konstanten: UPPER_SNAKE_CASE 
MAX_SIZE = 100
API_KEY = "secret"

# Klassen: PascalCase 
class UserAccount:
    pass

# Privat: führender Unterstrich 
_internal_value = 42
__very_private = "secret"

Ganze Zahlen (int)

Integers haben unbegrenzte Präzision:

riesig = 2 ** 1000
print(len(str(riesig)))

print(riesig % 1000)

Division & Integers

print(10 / 3)

print(type(10 / 3))

print(10 // 3)

print(-10 // 3)

Wahrheitswerte (bool)

Booleans sind eigentlich Integers:

print(True + True)

print(True * 42)

print(False - True)

Vergleichsoperatoren

print(5 == 5)

print(5 != 3)

print(10 > 5)

print(5 >= 5)

print("Python" > "Java")  # Lexikografischer Vergleich

Truthiness: Was ist wahr?

print(bool(0))

print(bool(42))

print(bool(""))

print(bool("0"))

print(bool([]))

print(bool([0]))

Vergleichsoperatoren: Chaining

x = 5
print(1 < x < 10)

print(10 < x < 20)

print(1 < x > 3)

Identität vs. Gleichheit

a = [1, 2, 3]
b = [1, 2, 3]
print(a == b)

print(a is b)

x = 256
y = 256
print(x is y)

x = 257
y = 257
print(x is y)

Kurzschlussauswertung

print(False and 1/0)

print(True or 1/0)

print(0 and print("Hallo"))

Gleitkommazahlen (float)

IEEE 754 Double Precision Fallstricke:

print(0.1 + 0.1 + 0.1)

print(0.1 + 0.1 + 0.1 == 0.3)

x = 0.1
print(f"{x:.20f}")

Vergleich von Gleitkommazahlen

a = 0.1 + 0.1 + 0.1
b = 0.3
tolerance = 1e-10
print(abs(a - b) < tolerance)

Extreme Werte

print(1e308)

print(1e309)

print(1e-324)

print(1e-325)

NaN und Infinity

print(float('inf') + 1)

print(float('inf') == float('inf'))

nan = float('nan')
print(nan == nan)

print(nan != nan)

Strings

# Verschiedene Anführungszeichen
single = 'Hallo'
double = "Welt"
print(single + " " + double)

triple = """Mehrzeiliger
String"""
print(triple)

String Indizierung & „Slicing“

# Indexzugriff
text = "Python"
print(text[0])

print(text[-1])

print(text[2:5])

Strings: immutability

Strings sind unveränderlich (immutable)

s = "Hallo"
s[0] = "h"

s = "Python"
original_id = id(s)
s += " ist toll"
print(id(s) == original_id)

String Basics: Methoden

text = "  Python Programmierung  "
print(text.upper())

print(text.lower())

print(text.strip())

print(text.replace("Python", "Java"))

Strings Aufteilen & Verbinden

# Aufteilen und Verbinden
words = "Python ist toll".split()
print(words)

print("-".join(words))

Strings und Unicode: Emoji

# Strings unterstützen vollständig Unicode
message = "Python ist toll! "
print(message)

# Emoji sind normale Zeichen
emoji_string = ""
print(len(emoji_string))

Escape Sequences

print("C:\new_folder\test.txt")

print(r"C:\new_folder\test.txt")

print("Zeile 1\nZeile 2\tTab")

String-Formatierung mit f-Strings

name = "Alice"
age = 25
print(f"Hallo, ich bin {name} und {age} Jahre alt")

Vorteile gegenüber älteren Methoden:

• Lesbar und intuitiv
• Direkte Variableneinbettung
• Schneller als .format() oder %-Formatierung
• Unterstützt Ausdrücke: f"Das Ergebnis ist {x + y}"

f-String Formatierung

number = 1234567.89
print(f"{number:,.2f}")

print(f"{number:>15,.2f}")

percent = 0.1234
print(f"{percent:.1%}")

f-String Besonderheiten

name = "World"
greeting = "Hello"
print(f"{greeting} {name}")

name = "Python"
print(f"{{{name}}}")

Aufgabe: Persönlicher Datenrechner

Schreibe ein Python-Skript, das persönliche Daten verarbeitet:

Gegeben:

• Name, Geburtsjahr, Größe (cm), Gewicht (kg)

Berechne und gib aus:

• Alter (aktuelles Jahr: 2025)
• BMI (Gewicht / (Größe in m)²)
• Personendaten als formatierte f-Strings
• Wahrheitswerte für: ist volljährig, ist normalgewichtig (BMI 18,5-24,9)

Kontrollstrukturen: Übersicht

Was sind Kontrollstrukturen?

• Mechanismen zur Steuerung des Programmflusses
• Bestimmen die Reihenfolge der Befehlsausführung
• Ermöglichen komplexe Programmlogik

Grundtypen:

1. Sequenz – Befehle nacheinander (Standard)
2. Verzweigung – Bedingte Ausführung (if, elif, else)
3. Wiederholung – Schleifen (for, while)

Verzweigungen

Konzept:

• Programme müssen Entscheidungen treffen
• Verschiedene Pfade basierend auf Bedingungen
• Ermöglicht adaptive und intelligente Programme

Syntax-Muster:

if bedingung1:
    # Code wenn bedingung1 wahr
elif bedingung2:
    # Code wenn bedingung2 wahr  
else:
    # Code wenn keine Bedingung wahr

Verzweigungen: Wichtige Konzepte

• Einrückung (Indentation) definiert Codeblöcke
• Bedingungen werden von oben nach unten geprüft
• Nur der erste wahre Zweig wird ausgeführt

Verzweigungen: Truthiness in der Praxis

name = ""
if name:
    print("Name ist vorhanden")
else:
    print("Kein Name angegeben")

name = "Alice"
if name:
    print("Name ist vorhanden")
else:
    print("Kein Name angegeben")

Komplexe Bedingungen

age = 17
has_id = True
if age >= 18 and has_id:
    print("Einlass gewährt")
elif age >= 16:
    print("Einlass mit Begleitung")
else:
    print("Kein Einlass")

age = 20
has_id = False
if age >= 18 and has_id:
    print("Einlass gewährt")
elif age >= 16:
    print("Einlass mit Begleitung") 
else:
    print("Kein Einlass")

Aufgabe

Schreibe ein Python-Programm um zu entscheiden, ob eine Rakete starten darf.

Eingaben:

• Treibstoff (%), Temperatur (°C), Crew (ja/nein), Wetter

Startbedingungen:

• Treibstoff ≥ 70%, Temperatur < 100°C, Crew bereit, Wetter ≠ "storm"

Ausgabe:

• " Startfreigabe erteilt!" oder "Start abgebrochen!" + Grund

Funktionen

Warum Funktionen?

Das DRY-Prinzip: "Don't Repeat Yourself"

FOOT = 0.3048
NAUTICAL_MILE = 1852.0

altitude_ft = 35000
altitude_m = altitude_ft * FOOT  # Flughöhe
print(f"Flughöhe: {altitude_ft} ft = {altitude_m:.0f} m")

distance_nm = 450
distance_m = distance_nm * NAUTICAL_MILE  # Strecke
print(f"Strecke: {distance_nm} nm = {distance_m:.0f} m")

# usw. ...

Probleme: Code-Duplikation, Fehleranfällig, schwer zu ändern

Funktionen: Die elegante Lösung

def fuss_zu_meter(fuss):
    return fuss * 0.3048

def seemeilen_zu_meter(seemeilen):
    return seemeilen * 1852.0


# Jetzt einfach und wiederverwendbar:
print(f"Flughöhe: {fuss_zu_meter(35000):.0f} m")
print(f"Landebahn: {fuss_zu_meter(8000):.0f} m")
print(f"Reichweite: {seemeilen_zu_meter(3000):.0f} m")

Vorteile: Wiederverwendbar, lesbar, wartbar, weniger Fehler!

Anatomie einer Funktion

def funktionsname(parameter1, parameter2):
    """Optionaler Docstring zur Dokumentation"""
    # Funktions-Code hier
    ergebnis = parameter1 + parameter2
    return ergebnis  # Optional: Rückgabewert

Aufbau:

• def - Schlüsselwort für Funktionsdefinition
• funktionsname - Aussagekräftiger Name (snake_case )
• () - Parameter in runden Klammern
• : - Doppelpunkt zum Start des Funktionsblocks
• Eingerückter Code-Block
• return - Optionale Rückgabe

Erste einfache Funktion

def mission_start():
    print(" Mission Control: Start-Sequenz initiiert")
    print(" Alle Systeme bereit für den Start!")

# Funktion aufrufen:
mission_start()

Funktionen mit Parametern

def mission_status(spacecraft):
    print(f" {spacecraft} Status: Alle Systeme nominal")
    print("Bereit für nächste Manöver-Phase")

mission_status("ISS")
mission_status("Artemis I")
mission_status("Dragon Capsule")

Mehrere Parameter

def flugdaten_anzeigen(flugzeug_typ, hoehe_ft, geschwindigkeit_kn):
    hoehe_m = hoehe_ft * 0.3048
    geschwindigkeit_kmh = geschwindigkeit_kn * 1.852
    print(f" {flugzeug_typ}")
    print(f"Höhe: {hoehe_ft} ft ({hoehe_m:.0f} m)")
    print(f"Geschwindigkeit: {geschwindigkeit_kn} kn ({geschwindigkeit_kmh:.0f} km/h)")
    
# Verschiedene Aufrufe:
flugdaten_anzeigen("Airbus A380", 35000, 450)
flugdaten_anzeigen(hoehe_ft=25000, flugzeug_typ="Boeing 737", geschwindigkeit_kn=420)

Rückgabewerte: return

def berechne_orbital_geschwindigkeit(hoehe_km):
    # Vereinfachte Berechnung für kreisförmige Umlaufbahn
    erdradius = 6371  # km
    gravitationskonstante = 398600  # km³/s²
    r = erdradius + hoehe_km
    geschwindigkeit = (gravitationskonstante / r) ** 0.5
    return geschwindigkeit

# ISS-Orbitalgeschwindigkeit berechnen:
iss_hoehe = 408  # km
v_orbital = berechne_orbital_geschwindigkeit(iss_hoehe)
print(f"ISS Orbitalgeschwindigkeit: {v_orbital:.2f} km/s")

Formeln für die Triebwerksanalyse

Wobei:

• = Spezifischer Impuls [s]
• = Schub [N]
• = Massenstrom [kg/s]
• = Standardfallbeschleunigung (9,81 m/s²)
• = Schub-Gewichts-Verhältnis [-]
• = Triebwerksmasse [kg]

Mehrere Rückgabewerte

def triebwerk_analyse(schub_newton, treibstoff_verbrauch_kg_s):
    spezifischer_impuls = schub_newton / (treibstoff_verbrauch_kg_s * 9.81)
    triebwerk_masse = 1000  # kg
    schub_gewichts_verhaeltnis = schub_newton / (triebwerk_masse * 9.81)
    return spezifischer_impuls, schub_gewichts_verhaeltnis

isp, twr = triebwerk_analyse(2200000, 700)
print(f"Spez. Impuls: {isp:.0f}s, Schub/Gewicht: {twr:.1f}")

Mehr zu „Tupeln“ (x, y) in Kapitel 5 (Datenstrukturen)!

Standardwerte für Parameter

def mission_planung(ziel, startdatum="TBD", crew_groesse=3, notfall_backup=True):
    print(f" Mission zum {ziel}")
    print(f"Start: {startdatum}")
    print(f"Crew: {crew_groesse} Astronauten")
    if notfall_backup:
        print(" Notfall-Backup-Systeme aktiv")
        
# Verschiedene Missionen:
mission_planung("Mond")
mission_planung("Mars", "2026-07-15")
mission_planung("ISS", crew_groesse=6)
mission_planung("Europa", startdatum="2030-01-01", notfall_backup=False)

Lokale vs. Globale Variablen

# Globale Variable
temperatur = 20  # °C

def berechne_luftdichte(hoehe_m):
    # Lokale Variable (nur in der Funktion sichtbar)
    temperatur = -50  # °C in der Stratosphäre
    # Diese lokale Variable "überdeckt" die globale
    dichte = 1.225 * (1 - 0.0065 * hoehe_m / 288.15) ** 4.256
    return dichte

print(f"Bodentemperatur: {temperatur}°C")  # 20°C (global)

luftdichte = berechne_luftdichte(10000)
print(f"Luftdichte in 10km Höhe: {luftdichte:.3f} kg/m³")

print(f"Nach Funktionsaufruf: {temperatur}°C")  # Immer noch 20°C!

Funktionen mit Verzweigungen

def startfreigabe_pruefen(treibstoff_prozent, wetter, crew_bereit, systeme_ok):
    if treibstoff_prozent < 95:
        return False, "Treibstoff unzureichend"
    elif wetter != "gut":
        return False, f"Wetter ungünstig: {wetter}"
    elif not crew_bereit:
        return False, "Crew nicht bereit"
    elif not systeme_ok:
        return False, "Systeme nicht nominal"
    else:
        return True, " Startfreigabe erteilt!"

# Verschiedene Szenarien testen:
freigabe, grund = startfreigabe_pruefen(98, "gut", True, True)
print(f"Freigabe: {freigabe} - {grund}")

freigabe, grund = startfreigabe_pruefen(90, "gut", True, True)
print(f"Freigabe: {freigabe} - {grund}")

Kompakte Startfreigabe-Funktion

def schnelle_startpruefung(treibstoff, wetter, crew, systeme):
    return (treibstoff >= 95 and wetter == "gut" and 
            crew and systeme)

# Verschiedene Raketen einzeln prüfen:
falcon_heavy = schnelle_startpruefung(98, "gut", True, True)
sls = schnelle_startpruefung(92, "gut", True, True)
starship = schnelle_startpruefung(99, "windig", True, True)

print(f"Falcon Heavy: {' GO' if falcon_heavy else ' NO-GO'}")
print(f"SLS: {' GO' if sls else ' NO-GO'}")
print(f"Starship: {' GO' if starship else ' NO-GO'}")